// Copyright 2006-2008 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/base/logging.h"

#include <cctype>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>

#include "src/base/debug/stack_trace.h"
#include "src/base/platform/platform.h"

namespace v8 {
namespace base {

    namespace {

        void DefaultDcheckHandler(const char* file, int line, const char* message);

        void (*g_print_stack_trace)() = nullptr;

        void (*g_dcheck_function)(const char*, int, const char*) = DefaultDcheckHandler;

        void PrettyPrintChar(std::ostream& os, int ch)
        {
            switch (ch) {
#define CHAR_PRINT_CASE(ch) \
    case ch:                \
        os << #ch;          \
        break;

                CHAR_PRINT_CASE('\0')
                CHAR_PRINT_CASE('\'')
                CHAR_PRINT_CASE('\\')
                CHAR_PRINT_CASE('\a')
                CHAR_PRINT_CASE('\b')
                CHAR_PRINT_CASE('\f')
                CHAR_PRINT_CASE('\n')
                CHAR_PRINT_CASE('\r')
                CHAR_PRINT_CASE('\t')
                CHAR_PRINT_CASE('\v')
#undef CHAR_PRINT_CASE
            default:
                if (std::isprint(ch)) {
                    os << '\'' << ch << '\'';
                } else {
                    auto flags = os.flags(std::ios_base::hex);
                    os << "\\x" << static_cast<unsigned int>(ch);
                    os.flags(flags);
                }
            }
        }

        void DefaultDcheckHandler(const char* file, int line, const char* message)
        {
            V8_Fatal(file, line, "Debug check failed: %s.", message);
        }

    } // namespace

    void SetPrintStackTrace(void (*print_stack_trace)())
    {
        g_print_stack_trace = print_stack_trace;
    }

    void SetDcheckFunction(void (*dcheck_function)(const char*, int, const char*))
    {
        g_dcheck_function = dcheck_function ? dcheck_function : &DefaultDcheckHandler;
    }

// Define specialization to pretty print characters (escaping non-printable
// characters) and to print c strings as pointers instead of strings.
#define DEFINE_PRINT_CHECK_OPERAND_CHAR(type)                                \
    template <>                                                              \
    void PrintCheckOperand<type>(std::ostream & os, type ch)                 \
    {                                                                        \
        PrettyPrintChar(os, ch);                                             \
    }                                                                        \
    template <>                                                              \
    void PrintCheckOperand<type*>(std::ostream & os, type * cstr)            \
    {                                                                        \
        os << static_cast<void*>(cstr);                                      \
    }                                                                        \
    template <>                                                              \
    void PrintCheckOperand<const type*>(std::ostream & os, const type* cstr) \
    {                                                                        \
        os << static_cast<const void*>(cstr);                                \
    }

    DEFINE_PRINT_CHECK_OPERAND_CHAR(char)
    DEFINE_PRINT_CHECK_OPERAND_CHAR(signed char)
    DEFINE_PRINT_CHECK_OPERAND_CHAR(unsigned char)
#undef DEFINE_PRINT_CHECK_OPERAND_CHAR

// Explicit instantiations for commonly used comparisons.
#define DEFINE_MAKE_CHECK_OP_STRING(type)                           \
    template std::string* MakeCheckOpString<type, type>(type, type, \
        char const*);                                               \
    template void PrintCheckOperand<type>(std::ostream&, type);
    DEFINE_MAKE_CHECK_OP_STRING(int)
    DEFINE_MAKE_CHECK_OP_STRING(long) // NOLINT(runtime/int)
    DEFINE_MAKE_CHECK_OP_STRING(long long) // NOLINT(runtime/int)
    DEFINE_MAKE_CHECK_OP_STRING(unsigned int)
    DEFINE_MAKE_CHECK_OP_STRING(unsigned long) // NOLINT(runtime/int)
    DEFINE_MAKE_CHECK_OP_STRING(unsigned long long) // NOLINT(runtime/int)
    DEFINE_MAKE_CHECK_OP_STRING(void const*)
#undef DEFINE_MAKE_CHECK_OP_STRING

// Explicit instantiations for floating point checks.
#define DEFINE_CHECK_OP_IMPL(NAME)                                              \
    template std::string* Check##NAME##Impl<float, float>(float lhs, float rhs, \
        char const* msg);                                                       \
    template std::string* Check##NAME##Impl<double, double>(                    \
        double lhs, double rhs, char const* msg);
    DEFINE_CHECK_OP_IMPL(EQ)
    DEFINE_CHECK_OP_IMPL(NE)
    DEFINE_CHECK_OP_IMPL(LE)
    DEFINE_CHECK_OP_IMPL(LT)
    DEFINE_CHECK_OP_IMPL(GE)
    DEFINE_CHECK_OP_IMPL(GT)
#undef DEFINE_CHECK_OP_IMPL

} // namespace base
} // namespace v8

namespace {

// FailureMessage is a stack allocated object which has a special marker field
// at the start and at the end. This makes it possible to retrieve the embedded
// message from the stack.
//
class FailureMessage {
public:
    explicit FailureMessage(const char* format, va_list arguments)
    {
        memset(&message_, 0, arraysize(message_));
        v8::base::OS::VSNPrintF(&message_[0], arraysize(message_), format,
            arguments);
    }

    static const uintptr_t kStartMarker = 0xdecade10;
    static const uintptr_t kEndMarker = 0xdecade11;
    static const int kMessageBufferSize = 512;

    uintptr_t start_marker_ = kStartMarker;
    char message_[kMessageBufferSize];
    uintptr_t end_marker_ = kEndMarker;
};

} // namespace

void V8_Fatal(const char* file, int line, const char* format, ...)
{
    va_list arguments;
    va_start(arguments, format);
    // Format the error message into a stack object for later retrieveal by the
    // crash processor.
    FailureMessage message(format, arguments);
    va_end(arguments);

    fflush(stdout);
    fflush(stderr);
    // Print the formatted message to stdout without cropping the output.
    v8::base::OS::PrintError("\n\n#\n# Fatal error in %s, line %d\n# ", file,
        line);

    // Print the error message.
    va_start(arguments, format);
    v8::base::OS::VPrintError(format, arguments);
    va_end(arguments);
    // Print the message object's address to force stack allocation.
    v8::base::OS::PrintError("\n#\n#\n#\n#FailureMessage Object: %p", &message);

    if (v8::base::g_print_stack_trace)
        v8::base::g_print_stack_trace();

    fflush(stderr);
    v8::base::OS::Abort();
}

void V8_Dcheck(const char* file, int line, const char* message)
{
    v8::base::g_dcheck_function(file, line, message);
}
